Area based optical proximity correction in raster scan printing

ABSTRACT

Methods and apparatus for correcting defects, such as rounded corners and line end shortening, in patterns formed via lithography are provided. Such defects are compensated for “post-rasterization” by manipulating the grayscale values of pixel maps.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No.10/883,210 filed Jul. 1, 2004, entitled “Area Based Optical ProximityCorrection In Raster Scan Printing,” (Attorney Docket No. APPM/9236-02),which is herein incorporated by reference.

The application is related to commonly-owned co-pending U.S. patentapplication Ser. No. 10/882,959 filed Jul. 1, 2004, entitled “OpticalProximity Correction In Raster Scan Printing Based On Corner MatchingTemplates,” filed herewith (Attorney Docket No. AMAT/9236), which isherein incorporated by reference.

BACKGROUND OF THE INVENTION

1. Field of the Invention

Embodiments of the present invention generally relate to lithographysystems used to print patterns or masks onto semiconductor wafers and,more particularly, to improving the acuity of pattern features printedthereby.

2. Description of the Related Art

In the photolithographic fabrication of integrated circuits, resistsensitive to radiant particle energy is exposed in predeterminedpatterns to define circuit features. In some cases, the energy is passedthrough masks which contain the patterns, thereby selectively exposing aphotoresist on a semiconductor body. In other cases, the resist is on amask substrate and the direction of the radiant energy itself iscontrolled to define patterns in the resist. Several sources of radiantenergy have been used, including ultraviolet light, visible light,coherent light, x-rays and electron beams (E-Beams).

One system for photolithographic fabrication of integrated circuits isdescribed in U.S. Pat. No. 4,796,038 entitled “Laser Pattern GenerationApparatus” which is assigned to the assignee of the present invention.In the system described therein, circuit patterns are written onto aworkpiece by directing laser beams and moving a workpiece relative tothe laser beams (e.g., while scanning the laser beams). In such systems,the intensity or dose of the laser beams at each exposed location iscontrolled by an array of pixels, commonly referred to as a pixel map,where the value of each pixel determines the dose at a correspondingexposed location. The dose or level of exposure is typically expressedas a grayscale value assigned to the corresponding pixel, typically zeroto a maximum, where zero corresponds to a zero-dose or white, and themaximum value corresponds to a full-dose or black.

The pixel map is generated by a rasterization process in which a datafile representing the pattern, such as a graphic design system (GDS) orMEBES format file, is transformed (using a component referred to as a“rasterizing engine”) into the individual pixel values by determiningover or on which pixels the pattern lies. The data file typicallyrepresents the image in a hierarchical format with data identifyingindividual vertices of the pattern features. One example of a techniqueand circuitry for performing such a rasterization process is describedin U.S. Pat. No. 5,553,170, entitled “Rasterizer for A PatternGeneration Apparatus,” which is assigned to the assignee of the presentinvention and incorporated herein by reference.

When writing a pattern with a lithography system, a number of boundaryor edge effects, such as diffraction limited wavelength effects andelectro-optical effects, for example, related to the power supplied in aradiated electron or laser beam, may result in defects in the actualwritten pattern. Factors in the writing process, such as sub-samplingtechniques used in the rasterization process and the use of a Gaussianshaped beam for writing, may also contribute to these defects. Thesedefects may include rounded corners and the shortening of lines due tonon-sharp edges (commonly referred to as line end shortening).

One approach to compensate for rounded corners involves manipulating thedata file to include additional geometries, in effect, to increase thearea of exposure in proximity to the corner areas. This approach isillustrated in FIG. 1, which shows both the standard process flow 102 ofrasterizing a data file 110 _(S) of a pattern 111, as well as a processflow 104 including such “geometry based” optical proximity correction(OPC). As illustrated, in the standard process flow 102, the data file110 _(S) is converted to a bit map 120 _(S) by a rasterization process.Due to the aforementioned boundary effects, however, writing thispattern based on the bit map 120 _(S) may result in a final writtenpattern 130 _(S) having rounded corners 132 _(S) (for contrast, theideal “sharp” corners 134 are shown as dashed lines). One metric used toquantify the rounding of corners, shown in the enlarged view of therounded corner 132 _(S) in FIG. 1A, is the distance between the tip ofthe ideal corner and the nearest location on the actual rounded corner,commonly referred to as corner pull back (CPB).

In the geometry-based OPC process flow 104, the data file 110 _(S) ismanipulated to add serifs 112 to the corners of the pattern 111,resulting in a new data file 110 _(G), which is rasterized to form a newbit map 120 _(G). Because of the serifs 112, this new bit map 120 _(G)will have additional pixels with non-zero values located in proximity tothe pattern corners. As a result, writing the pattern based on bit map120 _(G) may result in a written pattern 130 _(G) with corners 132 _(G)that are less rounded, having effectively been stretched outwardlytoward the ideal corners 134, “regaining” corner area and, thus,reducing CPB.

Unfortunately, there are a number of disadvantages associated with thisgeometry-based OPC process. One disadvantage is that, due to theaddition of the serifs 112, the number of corners that must berepresented increases and the data file 110 _(G) may growproportionally. For example, in the simple example illustrated in FIG.1, the original shape 111 has only four (convex) corners. However, eachserif 112 adds an additional two outer (convex) corners and two inner(concave) corners to each original corner of the pattern 111. Aspreviously described, these corners are typically expressed as verticesin the data file 110 _(G), and hence these additional corners may causethe data file 110 _(G) to grow by a factor of five as a result. As thedata file 110 _(G) grows, the amount of time required to transfer thepattern data to the rasterizer and, hence, overall processing time (timeto print), may grow proportionally.

Another disadvantage associated with geometry-based OPC is that,depending on the rasterization engine, certain ideal pixelconfigurations that may better correct for some defects may beunachievable through the addition of simple geometries, such as serifs112. A related disadvantage is that even if more complex geometries areadded in an effort to achieve a desired pixel configuration, the datafile will likely grow accordingly, thus exacerbating the previouslydescribed problems with data transfer.

Accordingly, there is a need for improved techniques for correctingdefects, such as rounded corners, in patterns written by lithography.Preferably, such techniques will result in little or no impact on datatransfer.

SUMMARY OF THE INVENTION

The present invention generally provides methods and systems forcorrecting corner in patterns printed via lithography.

One embodiment provides a method for adjusting corners of a pattern tobe written into a sensitive recording surface. The method generallyincludes generating sub-pixel data for use in creating grayscale valuesfor pixels by sampling sub-pixel locations of pixels that are covered bythe pattern, detecting corner pixels in the array, in which corners ofthe pattern lie, by examining the sub-pixel data, and adjustinggrayscale values of at least one of: one or more detected corner pixelsand one or more pixels neighboring one or more detected corner pixels.

Another embodiment provides a method for adjusting corners of a patternto be written into a sensitive recording surface. The method generallyincludes generating sub-pixel data by sampling sub-pixel locations ofpixels that are covered by the pattern, constructing an array of thepixels with corresponding sub-pixel data, detecting corner pixels in thearray by comparing a set of sub-pixel data in the array with one or morecorner detection overlays, and adjusting grayscale values of at leastone of: one or more detected corner pixels and one or more pixelsneighboring one or more detected corner pixels.

Another embodiment provides a system for writing a pattern in aresistive surface generally including a rasterizer, a corner detectionunit, and a corner correction unit. The rasterizer is generallyconfigured to generate sub-pixel data by sampling sub-pixel locations ofpixels that are covered by the pattern. The corner detection unit isgenerally configured to detect corner pixels in an array of pixels byexamining sub-pixel data corresponding to the pixels in the array. Thecorner correction unit is generally configured to adjust grayscalevalues of at least one of: one or more detected corner pixels and one ormore pixels neighboring the corner pixels.

Another embodiment provides a system for writing a pattern in aresistive surface generally including a rasterizer, a corner detectionunit, and a corner correction unit. The rasterizer is generallyconfigured to generate sub-pixel data by sampling sub-pixel locations ofpixels that are covered by the pattern. The corner detection unit isgenerally configured to detect corner pixels in the array by comparing aset of sub-pixel data in the array with one or more corner detectionoverlays. The corner correction unit is generally configured to adjustgrayscale values of at least one of: one or more detected corner pixelsand one or more pixels neighboring the corner pixels.

BRIEF DESCRIPTION OF THE DRAWINGS

So that the manner in which the above recited features of the presentinvention can be understood in detail, a more particular description ofthe invention, briefly summarized above, may be had by reference toembodiments, some of which are illustrated in the appended drawings. Itis to be noted, however, that the appended drawings illustrate onlytypical embodiments of this invention and are therefore not to beconsidered limiting of its scope, for the invention may admit to otherequally effective embodiments.

FIG. 1 illustrates a process for geometric-based optical proximitycorrection in accordance with the prior art.

FIG. 2 illustrates a process for pixel-based optical proximitycorrection in accordance with embodiments of the present invention.

FIG. 3 is a flow diagram of exemplary operations for pixel-based opticalproximity correction in accordance with embodiments of the presentinvention.

FIGS. 4A and 4B are an exemplary pattern that may be written inaccordance with embodiments of the present invention and a correspondinggrayscale value pixel map, respectively.

FIG. 5 is a flow diagram of exemplary operations for detecting cornersin accordance with embodiments of the present invention.

FIG. 6 is a flow diagram of exemplary operations for correcting cornersin accordance with embodiments of the present invention.

FIG. 7 is a map of grayscale values corrected in accordance withembodiments of the present invention.

FIGS. 8A and 8B illustrate exemplary corrected convex and concavecorners, respectively, in accordance with embodiments of the presentinvention.

FIG. 9 is a flow diagram of exemplary operations for template-basedcorner detection in accordance with embodiments of the presentinvention.

FIG. 10 illustrates a set of exemplary corner templates that may be usedfor corner detection in accordance with embodiments of the presentinvention.

FIG. 11 illustrates an exemplary hardware arrangement for template-basedoptical proximity correction in accordance with embodiments of thepresent invention.

FIG. 12 illustrates an exemplary binary pixel buffer in accordance withembodiments of the present invention.

FIG. 13 illustrates an undersampled pixel error that may be corrected inaccordance with embodiments of the present invention.

FIGS. 14A and 14B illustrate correction of a convex and concave corner,respectively, in accordance with embodiments of the present invention.

FIG. 15 is a flow diagram of exemplary operations for area-based opticalproximity correction in accordance with embodiments of the presentinvention.

FIG. 16 illustrates exemplary sub-pixel maps in accordance withembodiments of the present invention.

FIGS. 17A and 17B illustrate exemplary shapes, the corners of which maybe corrected in accordance with embodiments of the present invention.

FIGS. 18A and 18B illustrate exemplary convex and concave cornerdetection overlays, respectively, in accordance with embodiments of thepresent invention.

FIGS. 19A-19D illustrate application of exemplary convex cornerdetection overlays in accordance with embodiments of the presentinvention.

FIGS. 20A-20C illustrate the resolution of adjacent corners inaccordance with embodiments of the present invention.

FIGS. 21A and 21B illustrate the generation of exemplary 2-bit and 4-bitcorner tags, respectively, in accordance with embodiments of the presentinvention.

FIG. 22 illustrates an exemplary set of corner correction registers inaccordance with embodiments of the present invention.

FIG. 23 illustrates application of a set of corner correction registersin accordance with embodiments of the present invention.

FIG. 24 illustrates exemplary hardware for use in area-based cornercorrection in accordance with embodiments of the present invention.

FIG. 25 illustrates a flow diagram of exemplary operations forarea-based corner correction in accordance with embodiments of thepresent invention.

FIG. 26 illustrates an exemplary hardware implementation of a cornerdetection unit in accordance with embodiments of the present invention.

FIG. 27 illustrates exemplary data structures based on sub-pixel data inaccordance with embodiments of the present invention.

FIG. 28 illustrates an exemplary block-based algorithm for implementingcorner detection overlays in accordance with embodiments of the presentinvention.

DETAILED DESCRIPTION

Embodiments of the present invention generally provide methods andapparatus for correcting defects, such as rounded corners and line endshortening, in patterns formed via lithography using radiated beams,such as laser or electron beams. Rather than compensate for such defectsby manipulating the pattern data file to include additional geometricobjects, defects are compensated for “post-rasterization” bymanipulating the grayscale values of pixel maps. As a result, the sizeof the data file is not increased and data transfer time may beunaffected.

Performing defect compensation after rasterization may provide a greaterdegree of flexibility in the exact pixel configurations achievable tomanipulate (increase or decrease) dose proximate the corners. Further,as will be described herein, pixel-based defect compensation may beperformed on local areas of the pattern, allowing the processing to bedistributed. For example, if the defect compensation is performed insoftware, processing may be distributed across multiple processorsacting in parallel, with each processor working on a relatively smallportion of the pattern without requiring knowledge of the rest of thepattern. Similarly, if the defect compensation is performed in hardware,the processing may be distributed among multiple hardware componentsacting in parallel.

Pixel-Based Corner Enhancement

FIG. 2 illustrates a process flow 202 including “pixel based” opticalproximity correction (OPC) for writing a pattern 111 via lithography. Asillustrated, a data file 110 _(S) may be converted to a bit map 120 _(S)by a rasterization process, as in the standard flow 102. However, ratherthan using this standard bit map 120 _(S) to write the pattern 111,which may result in rounded corners 132 _(S), an enhanced bit map 120_(P) is used. The enhanced bit map 120 _(P) is generated by manipulatinggrayscale values of pixels in the standard bit map 120 _(S). Thegrayscale values may be manipulated, using various techniques describedherein, in an effort to modify the doses of energy provided at or inproximity to corner pixels when writing the pattern, in an effort toachieve corners 132 _(P) more closely approximating the ideal corners ofthe pattern 111.

FIG. 3 illustrates exemplary operations 300 that may be performed aspart of the process flow 202. The operations 300 begin, at step 302, byreceiving the data file of a pattern to be written. The data file may bein any suitable file format representing the geometric features of thepattern, such as the graphic design system (GDS) or MEBES formats. Atstep 304, the data file is rasterized to create a map of pixels withgrayscale values. For some embodiments, pixels may be composed of anarray of sub-pixels and the rasterization process may involvedetermining how many of a limited number of sample sub-pixels (orsubsamples) the pattern covers. Setting the grayscale value for eachpixel may then essentially involve counting all of the coveredsubsamples as described in the previously referenced U.S. Pat. No.5,533,170. In other words, in general, the greater the area of a pixelcovered by the pattern, the higher the grayscale value will be.

At step 306, pixels on which corners of the pattern overlay(hereinafter, “corner pixels”) are identified. At step 308, thegrayscale values of the identified corner pixels and/or neighboringpixels are adjusted. While detecting and correcting these corner pixelsare the basic steps involved in pixel-based correction of roundedcorners, a number of different approaches may be taken to accomplisheach. As will be described throughout, deciding the exact approach totake for each may involve a variety of considerations, includingtradeoffs between cost and performance.

The challenge of detecting corner pixels may be demonstrated withreference to FIG. 4A, which illustrates an exemplary pattern 411overlaying a grid 400 of pixels 402. As illustrated, the pattern 411 hasfive convex (outer) corners 404 and one concave (inner) corner 406.While the pixels containing these corners may be readily discernable toa viewer, what is needed is an algorithm that can be implemented inhardware and/or software that is capable of reliably detecting thesecorner pixels. One such algorithm detects corner pixels by examininggrayscale values of pixels neighboring the corner pixels.

As previously described, the grayscale value of each pixel 402 may beindicative of what percentage of the pixel is covered by the pattern411. This is illustrated in FIG. 4B, which shows a map 450 of grayscalevalues corresponding to the pattern 411 shown in FIG. 4A. For purposesof illustration, grayscale values ranging from 0-16 are used, with theassumption that higher grayscale values correspond to greater pixelcoverage, such that the minimum grayscale value (0) represents whitewhile the maximum grayscale value (16) represents black. Accordingly,pixels with no portion covered by the pattern 411 are zero, pixelscompletely covered by the pattern 411 are 16, while pixels partiallycovered are some intermediate value, somewhat proportional to the amountof coverage.

CORNER DETECTION BASED ON ZERO GRAYSCALE NEIGHBORS

FIG. 5 illustrates exemplary operations 500 for detecting corner pixelsby examining grayscale values of pixels surrounding the corner pixels.For different embodiments, the operations 500 may be performed insoftware, hardware, or a combination thereof. For example, for someembodiments, the pixel map may be transferred from a rasterizing engineto one or more general purpose processors, each executing a program toperform the detection. For other embodiments, hardware components, suchas application specific integrated circuits (ASICs) or fieldprogrammable gate arrays (FPGAs) may perform the detection.

In any case, the operations 500 begin, at step 502, by receiving a pixelmap 502. At step 504, a loop of operations 506-522 is entered, to beperformed on each pixel. In other words, each pixel is examined todetermine if it is a corner pixel and, if so, what type, by examiningthe number of neighboring pixels having a zero grayscale value.

As illustrated in FIG. 4B, each corner pixel has at least oneneighboring pixel with a zero grayscale value. This follows from thefact that a corner lies on an intersection between two edges. As eachedge is a transition from black to white, each edge pixel may beidentified either as a pixel having a “gray value” between black andwhite, and/or (even if the edge is aligned with the pixel grid and, thushas a maximum grayscale value) must have at least one zero grayscalevalue neighboring pixel. Further, each different type of corner pixel(convex and concave) may have a different number of zero grayscaleneighbors. Thus, the number of zero grayscale neighbors may be useful indetecting the presence of pixel corners, classifying them (as convex orconcave), and determining their orientation.

Accordingly, at step 506, the number (N_(Z)) of neighboring pixels (of apixel being examined) with zero grayscale is counted. For example, asillustrated in FIG. 4B, a 3×3 array 452 of pixels may be assembled, witha pixel 454 under examination in the center. The outer pixels of thearray 452 having zero grayscale may then be counted.

As previously described, each corner pixel must lie on an edge and eachedge pixel must have at least one zero grayscale neighbor. Accordingly,pixels having no zero grayscale neighbors, as determined at step 510,are not edge or corner pixels and, therefore, further processing is notrequired. In typical patterns, only a small percentage of pixels (e.g.,approximately 10%) may be edges. Thus, quickly testing to determine apixel is not an edge pixel and, thus not a corner pixel, may preventunnecessary subsequent processing of non-edge pixels.

As illustrated in FIG. 4B, convex corner pixels 454 may have five zerograyscale neighbors. While not shown, some convex corner pixels may haveonly four zero grayscale neighbors, for example, if a small feature of apattern, offset from the corner by one pixel, extends outwardly onepixel away from the corner. Accordingly, if a pixel has four or fivegrayscale neighbors, as determined at step 512, that pixel may be markedas a convex corner, at step 514.

Concave corner pixels 456, on the other hand, have only one zerograyscale neighbor (located on a diagonal). Accordingly, if a pixel hasonly one grayscale neighbor, as determined at step 516, that pixel maybe marked as a concave corner, at step 518. In some cases, undersamplingerrors may result in a zero grayscale value for a pixel even though thepattern actually impinges on the pixel. In such cases, a pixel may bemismarked as a concave corner due to the erroneous zero grayscale.Further, in some cases, a vertex of a trapezoidal jog may also have asingle zero grayscale neighbor. As a result, the marking in step 518 mayactually indicate the pixel is “possibly” a concave corner and furtherprocessing (e.g., performed as part of post-corner detection processing,at step 524) may be required to resolve whether the pixel is, in fact, aconcave corner. For some embodiments, undersampled pixels may bedetected during rasterization (e.g., prior to receiving a pixel map, atstep 502) and corrective measures may be taken to avoid sub-samplederrors, such as setting a single sub-sample bit.

Once pixels are identified as corner pixels, whether concave or convex,their orientation (e.g., Upper Left, Upper Right, Lower Left, or LowerRight) may be determined, at step 520. Any suitable technique may beutilized to determine the orientation of the corners. For example, theorientation of concave corners may be determined by identifying thelocation of the single zero grayscale diagonal neighbor. Similarly, theorientation of convex corner pixels may be determined by identifying thelocation of a single non-zero grayscale diagonal neighbor.

Pixels having some number of zero grayscale neighbors (other than 0, 1,4, or 5) may represent some other type of feature. For example, a jog orneck may have two or three zero grayscale neighbors, a one pixel-wideline may have six or seven zero grayscale neighbors, while an isolatedpixel may have eight zero grayscale neighbors. Such pixels may be markedaccordingly, at step 522.

For some embodiments, once each pixel has been examined, post-cornerdetection processing may be performed, at step 524. Post-cornerprocessing may include various operations, such as resolvingundersampling errors (which may also be done during rasterization),resolving adjacent corners, and detecting trapezoidal jogs. For example,undersampling errors may be resolved by additional processing todetermine if any portion of a pattern overlays a zero grayscale pixelwithout impinging on a subsampled pixel. Resolving adjacent corners mayinvolve examining pixels adjacent to (or in proximity to) an identifiedcorner, in an effort to ensure the addition of dose during subsequentconvex corner correction does not result in bridging between adjacentfeatures or that removal of dose during subsequent concave cornercorrection does not result in loss of continuity.

For some embodiments, external information, such as data from theoriginal pattern data file, may be used to assist in this post-cornerprocessing. Such external information may provide precise informationregarding the pattern relative to the pixel grid, not readily availablefrom the grayscale pixel map, such as precise locations of a pattern toresolve undersampling errors.

Corner Correction

After post-corner detection processing, corner correction may beperformed, at step 526. FIG. 6 illustrates exemplary operations 600 forcorrecting corners. The operations 600 begin, at step 602, by receivinga set of pixels identified as corner pixels. At step 604, a loop ofoperations 608-614 to be performed on each corner pixel is entered. Aspreviously described, corner correction may involve manipulatinggrayscale values of corner pixels and/or neighboring pixels in an effortto add dose to “stretch” convex corners (or remove dose to “shrink”concave corners) to more closely match the ideal corners of the patternbeing written.

Thus, if a corner pixel is a convex pixel, as determined at step 606,the grayscale value of the corner pixel is increased by a correctionfactor, at step 608. In some cases, the correction factor may beadjustable, for example, by a user via a graphical user interface (GUI),and the exact value chosen may be based, for example, by the amount ofcorrection needed, as determined from previous trials of writing thesame pattern. For some embodiments, separate correction factors may beused to correct convex and concave corners and each may be independentlyadjustable by a user. More complex schemes involving multiple correctionfactors, for adjusting the grayscale value of multiple neighboringpixels are also possible. In either case, in some instances, the sum ofthe original grayscale value and the correction factor may exceed themaximum pixel value. As it is not possible to add more dose to thecorner pixel, the remainder may be added to the neighboring pixeldiagonally outward, at step 610.

On the other hand, if a corner pixel is a concave pixel, the grayscalevalue of the corner pixel is decreased by the correction factor, at step612. If the correction factor is greater than the original grayscalevalue, the grayscale value of the corner pixel will be set to zero. Toensure the desired amount of dose is removed to correct the concavecorner, the remainder may then be subtracted from the neighboring pixeldiagonally inward, at step 614.

For some embodiments, the horizontal and vertical (i.e., X and Y)dimensions of a pixel may not be symmetrical. For example, the Ydimension may be greater than the X dimension, resulting in pixels thatare taller than they are wide. Therefore, diagonal neighboring pixelsmay not be located on an exactly 45 degree line, but rather, on adifferent angle determined by the pixel dimensions. Accordingly, in suchcases, in order to increase dose diagonally outward or decrease dosediagonally inward, the grayscale value of more than one pixel may needto be adjusted (e.g., ratiometrically, based on the X and Y dimensions).Further, in some cases, non-cartesian pixel grids, such as hexagonalgrids may be utilized. In such cases, the addition or subtraction ofdose may be propagated accordingly.

FIG. 7 illustrates an exemplary map 750 of “corrected” grayscale valuesgenerated by performing the operations 600 on the original grayscalevalues shown in FIG. 4B. For illustrative purposes, it is assumed thecorrection factor is 10, that a single correction factor is applied tocorrect both concave and convex corners, and that the grayscale valuesrange from 0 to 16. Beginning with the upper convex corners, theoriginal grayscale values of these corner pixels was 2. Accordingly,adding the correction factor of 10 to these corner pixels yields acorrected pixel value of 12. Similarly, adding the correction factor of10 to the original grayscale value of the lower left convex cornerpixels yields corrected pixel values of 14.

The sum of the correction factor of 10 and the grayscale value of thelower right convex corner pixel, on the other hand, is greater than themaximum grayscale value of 16. Accordingly, this corner pixel is set tothe maximum value of 16 and the remainder of 6 is propagated to theneighboring pixel diagonally outward. In a similar manner, as thegrayscale value of the (lower) concave corner pixel value (6) is lessthan the correction factor (10), its corrected grayscale value is set tozero, while the remainder (4) is subtracted from the neighboring pixeldiagonally inward, resulting in a corrected grayscale value of 12 forthis pixel.

As illustrated in FIG. 8A, the effect of increasing the grayscale valuesat and near the convex corners is that the corrected convex corner 832_(P) is stretched out relative to, and approaches the sharp edges of theideal pattern more closely than the uncorrected convex corner 832 _(S).With similar effect, as illustrated in FIG. 8B, decreasing the grayscalevalues at and near the concave corners pulls back the corrected concavecorner 834 _(P) relative to the uncorrected convex corner 834 _(S).

Template-Based Corner Detection

Another approach to detecting corner pixels involves applying cornertemplates to an array of pixels centered on a pixel under examination.This template-based approach also relies on information regarding zerograyscale neighbors of corner pixels to identify and classify cornerpixels. For some embodiments, this information may be captured in aBoolean pixel map which identifies pixels as having either a zero ornon-zero grayscale value. As will be described in further detail below(with reference to FIGS. 11 and 12), this approach may be particularlywell suited for efficient implementation in hardware. FIG. 9 illustratesexemplary operations 900 for performing such template-based cornerdetection.

The operations 900 begin, at step 902, by receiving an original pixelmap of grayscale values, for example, from a rasterizer. At step 904, aBoolean pixel map is generated, wherein a value of each pixel in theBoolean pixel map indicates whether a corresponding pixel in theoriginal pixel map has a non-zero grayscale value. For example, aBoolean pixel with a value of 1 may indicate a corresponding pixel inthe original pixel map has a non-zero grayscale value while a pixel inthe Boolean pixel map with a value of 0 may indicate a correspondingpixel in the original pixel map has a zero grayscale value. For someembodiments, Boolean pixel values may be generated by simply logicallyOr'ing the bits of a corresponding grayscale value in the original pixelmap.

At step 906, a loop of operations 908-914 to be performed for eachBoolean pixel is entered. At step 908, an array of pixels centered on aselected pixel under examination is constructed. At step 910, a set ofcorner templates is applied to the constructed array, with each cornertemplate corresponding to a corner of a certain type and orientation. Ifthe array does not match any of the templates, as determined at step912, the selected pixel is not marked as a corner pixel and theoperations return to step 906 to select another pixel to examine. On theother hand, if the array does match one of the templates, the selectedpixel is marked as a corner of the type corresponding to the matchingtemplate. Once all the pixels have been examined, corner correction isperformed at step 916.

The size of the array of pixels assembled for comparison against thetemplates may be chosen as the minimum number of pixels required to beexamined to reliably identify and classify all possible types of cornerpixels and, in some cases, distinguish between corner pixels andtrapezoidal jogs. For some embodiments, the array may be a 5×5 array ofpixels.

FIG. 10 illustrates an exemplary set 1000 of corner matching templates1002-1032 that may be applied to a 5×5 array of pixels to determine if apixel centered therein is a corner pixel. In other words, for someembodiments utilizing these templates, in order for a center pixel “P”to be detected as a corner, pixel “P” and its surrounding 24 neighborsmust match one of the Boolean corner detection templates shown in FIG.10. It should be noted that the templates shown in FIG. 10 are intendedto detect Manhattan corners (formed by intersecting horizontal andvertical edges) only and are, in fact, designed to reject corners thatare closer than one pixel in two directions, which may be trapezoidaljogs that should not be corrected to avoid causing edge roughness.

In each template shown in FIG. 10, white (no cross-hatching) is used toindicate a ‘0’ Boolean pixel (grayscale=0), a first cross-hatching isused to indicate a ‘1’ Boolean pixel (grayscale value>0), while a secondcross-hatching is used to indicate a “don't care” condition. Templatesto detect both convex and concave corners of each type of orientation(upper-left, upper-right, lower-left, and lower-right) are provided.

The convex corner templates 1002-1008 are relatively straightforward andassume that a convex corner extends with no other corner (or feature)closer than one pixel in two directions. The additional white space inthe corner of the region diagonally opposite the detected corner in theconvex templates 1002-1008 is designed to guarantee that no featureexists in an area that will possibly be covered by a propagated grayvalue. If a feature existed in this area, propagation could causebridging between abutting features.

The concave corner detection templates 1010-1032 assume a two pixelspacing as well. In the absence of sub-pixel information (which will bedescribed in further detail below), this check may be important to avoidcorrecting corners that are really trapezoidal jogs, which may causeedge roughness. In other words, since any aliased, non-undersampled linedrawn through a rectilinear grid can only jog by at most a single pixelin one of the orthogonal Manhattan directions, this two pixel check maybe used to ensure that all angled lines are rejected as candidates forcorner correction. The concave corner templates 1018-1032 are designedto handle the special cases of interior concave regions with a clear(white) area of only a single pixel in height.

As illustrated, all the concave templates 1010-1032 require a 1-pixelnon-zero grayscale surround in every direction, other than diagonallyoutward, from the corner pixel. This is to guard against loss ofgeometric connectivity in the printed image that might occur if too muchdose is removed from the corner pixel as to separate features thatshould remain contiguous. This also illustrates how judicious design ofthe templates may reduce or eliminate the need to perform some of thepreviously described post-detection corner processing (e.g., step 524 ofFIG. 5) and may, thus, improve system performance (by reducingprocessing time).

Exemplary Hardware for Template-Based Corner Detection

FIG. 11 illustrates an exemplary hardware implementation 1100 that maybe used to perform the template-based corner detection operationsdescribed above. As previously described, a rasterizer 1104 may generatea grayscale pixel map based on a data file 1102 representative of apattern to be printed. As illustrated, the pixel data output from therasterizer 1104 may be stored in a frame buffer 1106, where it may beaccessed by a corner detection and correction (hardware) unit 1110. Asillustrated, the corner detection and correction unit 1110 mayaccumulate rows of pixels in a series of buffers.

The buffers may include an original grayscale buffer 1112 (e.g., adirect copy of the incoming grayscale pixel values), a Boolean pixelbuffer 1114, and a correction pixel buffer 1116. As previouslydescribed, the Boolean values stored in the Boolean pixel buffer 1114may be generated by logically OR'ing bits of pixels in the originalgrayscale buffer 1112. The correction pixel buffer 1116 is also a copyof the incoming gray value pixels, but may be modified in real time by acorner correction unit 1120 as corners are detected. As will bedescribed in greater detail below, the modifications to the correctionpixel buffer 1116 are based on the gray values in the (unmodified)original grayscale buffer 1112. This may be done in an effort to avoiddouble modification of pixels when corners are detected in closeproximity and the corrections interfere.

For some embodiments, pixels may enter the corner detection andcorrection unit 1110 in rows of sixteen pixels, which may be processedin parallel, thus further improving performance. In order to assemble5×5 pixel arrays, five rows may be accumulated before the cornerdetection can begin. Further, in order to perform corner correction onpixels at the edges of a 16 pixel row, 2 border pixels at either edge(for a total row width of 20 pixels) may also be fed into the cornerdetection and correction unit. As illustrated in FIG. 12, the Booleanpixel buffer 1114 may be organized as a 5-pixel row tall by 16 pixelwide register (with additional boundary pixels 1220L and 1220R).

As shown in FIG. 12, the corner correction unit 1120 may be configuredto simultaneously apply the corner templates to multiple 5×5 pixelarrays 1254 ₁₋₁₆ in parallel, with each array centered on a pixel(P₁₋₁₆) in the center row 1210 of the register. For some embodiments,immediate border pixels (e.g., 1220 _(L) and 1220 _(R)) may also beexamined to determine if corrections thereto spill into pixels P₁₋₁₆.The corner detection unit 1118 may include relatively simple logic tomap the corner templates to a set of logic equations that are checkedusing the Boolean values of the current pixel (P_(i)) under examinationand its surrounding neighbors (N₀₋₂₃). For example, the equation for theconvex upper left (CVXUL) corner (e.g., template 1002 in FIG. 10) may beimplemented as:

CVXUL=P&N0&N6&N7&!N1&!N2&!N3&!N4&!N5

where the & symbols represent logic AND functions, while the ! symbolsrepresent logic invert functions. For concave corners, all of thetemplate maps for a particular corner orientation may be logically“ORed” together. For example, the equation for a concave upper left(CCVUL) corner (e.g., templates 1010,1018, and 1026 in FIG. 10) may beimplemented as:

CCVUL=(P&N0&N9&N4&N1&N2&N3&N5&N6&N21&!N7&!N8&!N22)|

(P&N0&N9&N4&N1&N2&N3N5&N6&N21&N22&N23&!N7)|

(P&N0&N9&N4&N1&N2&N3&N5&N6&N8&N21&N23&!N7)

where the | symbols represent logic OR functions.

Compensating for Undersampled Pixels

As previously described, undersampled pixels may present a problem toalgorithms that detect corners based on zero grayscale values, such asthe template-based corner detection algorithm. A pixel is generallydefined to be undersampled when a shape slightly impinges on the pixel,but does not cover any of the sampled sub-pixel locations (“subsamples”)during rasterization. The resulting pixel will have a zero grayscalevalue to the detection algorithm, which will cause the corner detectionto fail (as the templates require a corner pixel to have a non-zerograyscale value).

FIG. 13 illustrates a portion of a pixel map 1300 with subsamplelocations 1303. The shape 1301 shown in the pixel map 1300 partiallycovers four pixels 1302 ₀₋₃. For illustrative purposes, it is assumedthat the shape 1301 is surrounded by white (zero grayscale pixels). Aspreviously described, for some embodiments, the grayscale value of apixel may be determined simply by counting the number of subsamplelocations 1303 of that pixel covered by the shape 1301. Note, however,that the pixel 1302 ₀ in the lower right corner has no subsamplelocations 1303 covered and ends up with a gray value of zero. The effectof this is shown in the binary 5×5 Boolean pixel array 1314, with aBoolean pixel 1316 corresponding to the undersampled pixel 1302 ₀ havinga ‘0’ value. As a result, tests against the corner matching templateswill indicate that no corners are present, while clearly a convex lowerright corner exists, as well as three other convex corners (upper right,upper left and lower left).

One solution to this problem is to enhance the rasterization hardware toturn on (set) a bit corresponding to the center subsample of a pixelwhen a shape impinges on that pixel but causes no subsamples to be setduring normal rasterization. Setting this bit may result in a gray valueof one for the pixel which may, in turn, result in a Boolean value of“1” for the pixel in the Boolean pixel map. Accordingly, setting thisbit in the present example will allow all convex corners to be detected.If during rasterization, a subsequent shape causes other subsamples inthe undersampled pixel to be turned on, the hardware may be configuredto clear the center subsample bit before modifying the pixel with thefinal gray value. The hardware may recognize that a subsample is “on”due to an undersampling condition because only the center subsample ofthe entire pixel is set which is unlikely to be a valid shape.

Adjusting the Corner Correction Buffer

As previously described, in addition to the original (unmodified)grayscale pixel buffer 1112 and Boolean pixel buffer 114, a separatecorrection buffer 1116 may be maintained and used to make the actualadjustments for corner correction. Referring back to FIG. 11, the cornercorrection and detection unit 1110 may include the corner correctionunit 1120 that receives an identification (e.g., a map) of cornersdetected by the corner detection unit 1118 and modifies pixels in thecorrection buffer 1116, based on pixel values in the original grayscalebuffer. Corrected pixel values may then be read out of the correctionbuffer 116, for use in controlling exposure during the actual writingprocess (e.g., by modulating one or more laser beams).

FIG. 14A illustrates one example of convex corner correction using thethree separate buffers. As illustrated, convex upper right corner of anexemplary shape 1411 lies in a pixel 1415, resulting in the grayscalevalues shown in an original grayscale buffer 1412 _(A) and thecorresponding Boolean pixel values shown in a Boolean pixel buffer 1414_(A). As a result, the convex upper right corner is detected whenapplying the corner templates to the Boolean 5×5 pixel array centered onthe pixel 1415.

Correction may be performed by adjusting grayscale values in thecorrection buffer 1416 _(A) at or near the corner pixel, based on theoriginal grayscale values and a correction factor, assumed to be 10 inthis example. As previously described, for some embodiments, thecorrection factor may be stored in an adjustable convex correctionregister and separate correction registers may be provided for convexand concave corner correction. As shown, the pixel 1415 has a grayscalevalue of 12 in the original grayscale buffer 1412 _(A). To correct thedetected corner, the dose specified in the convex correction register(10) is added to the original grayscale value.

For some embodiments, if this addition yields a grayscale value that isgreater than the maximum allowable grayscale value, the remaining dosemay be propagated to adjacent pixels. One approach to propagate theremaining dose is to add the excess to the pixel diagonally outward fromthe corner pixel, as shown. In the current example, adding thecorrection dose of 10 to the original grayscale value of 10 yields a sumof 22, which exceeds the maximum grayscale value of 16 by 6. As shown,the corner pixel is set to 16 and the excess value of 6 is propagated tothe outwardly diagonal pixel 1417. As previously described, for someembodiments, the pixel grid may not be symmetric in the x and y axes andthe excess value may be propagated to multiple pixels in a“ratio-metric” manner. As illustrated, the corrected grayscale valuesare placed in the correction buffer 1416 _(A), while the original buffer1412 _(A) remains unchanged.

FIG. 14B illustrates one example of concave corner correction using thethree separate buffers. As illustrated, a concave lower left corner ofan exemplary shape 1411 lies in a pixel 1418, resulting in the grayscalevalues shown in an original grayscale buffer 1412 _(B) and thecorresponding Boolean pixel values in a Boolean pixel buffer 1414 _(B).As a result, the concave lower left corner is detected when applying thecorner templates to the Boolean 5×5 pixel array centered on the pixel1418. For correction, the dose specified in the concave correctionregister is subtracted from the grayscale value of the pixel 1418 in theoriginal buffer 1412 _(B).

If this subtraction yields a grayscale value that is less than theminimum gray value allowed (e.g., zero), the remaining dose may besubtracted from adjacent pixels. In the illustrated example, the cornerpixel 1418 has a grayscale value of 6. Hence, when the concavecorrection dose, assumed to be 10 for this example, is subtracted fromthe grayscale value, the corner pixel grayscale value in the correctionbuffer is set to zero, leaving a residual dose of 4 that is subtractedfrom the inwardly diagonal neighboring pixel 1420. Again, only thecorrection buffer 1416 _(B) is modified and the original grayscalebuffer 1412 _(B) remains unchanged.

As previously described, various types of additional processing may beperformed to accommodate special cases when correcting corners. Forexample, if multiple corners exist in a small area, the corrections forthe corners may cause the “interference” as the same pixel may bemodified multiple times (e.g., the grayscale value of the pixel may bemodified first as a corner pixel and later as a neighboring pixel of anearby corner). Depending on the order in which the pixels areprocessed, a corrected pixel may end up with an unexpected value.Various approaches may be taken to handle this situation, such asaccumulating the corrected values and averaging, or by using a min-maxapproach.

While the averaging approach may result in a compromise betweendifferent corrected values, the min-max approach is straight forward andwill yield the same results as if the corrections were logically “ORed”(in the convex case) or logically “ANDed” (in the concave case).Applying the min-max approach for convex corners, if a pixel is detectedas previously modified, it will only be updated if the new value isgreater than the current value. In this way, the corner that “wins” isthe corner requiring the most dose to be added to the corner pixeland/or neighboring pixels. Applying the min-max approach for concavecorners, if a pixel is detected as previously modified, it will only beupdated if the new value is less than the current value. In this way,the corner that “wins” is the corner requiring the most dose to besubtracted from the corner pixel and/or neighboring pixels.

Area-Based Corner Detection

Another approach to detecting corner pixels involves examining sub-pixelinformation, in effect, to determine how much area of a pixel is coveredby a rendered shape. Because sub-pixel data (e.g., 16-bit sampledsub-pixels) is examined rather than grayscale values (which may merelybe a 5-bit sum of the sampled sub-pixels covered by a rendered image), agreater degree of precision may be achieved when detecting corners. Forexample, as will be described in greater detail below, a preciseposition within the pixel in which the corner lies may also bedetermined which may, in turn, allow for greater flexibility whencorrecting corners via the addition or subtraction of radiated dose.

Utilizing an area coverage approach for corner detection based onsub-pixel data may be more accurate than using pixel based cornerdetection, because pixel based systems rely on grid snap and cantherefore be fooled by undersampled pixels. While this undersampling maybe overcome, as previously described, with enhancements inrasterization, the area coverage approach described herein may avoid theproblem by utilizing corner detection overlays to detect corner pixels.With careful design, the corner detection overlays may be designed toensure that corners are detected, regardless of undersampling errors. Aswill be described, these overlays may, in effect, be moved around withinan array of pixels, in sub-pixel (e.g., quarter pixel) steps, to detectprecise corner locations.

FIG. 15 illustrates exemplary operations 1500 for performing sucharea-based corner detection. The operations 1500 begin, at step 1502, byreceiving sub-pixel data of a rasterized image. At step 1504, arrays ofpixels with sub-pixel data are constructed. At step 1506, a loop ofoperations 1508-1514 to be performed for each array of sub-pixel data isentered. At step 1508, corner detection overlays are applied to aselected array in order to detect corners lying in pixels thereof. Atstep 1510, corner data is generated based on the results of applying thecorner detection overlays. This corner data may include a type andorientation of detected corners, marked at step 1512, as well as a setof corner tags that identify positions of the detected corners withintheir corresponding corner pixels, created at step 1514. Once theoperations 1508-1514 have been performed for each array, cornercorrection is performed, at step 1516. Exemplary operations forperforming corner correction utilizing corner tags is described below,with reference to FIG. 25.

The sub-pixel data received at step 1502 may include bit strings of dataindicating which of a corresponding set of sampled sub-pixel locationsare covered by a pattern to be written. FIG. 16 illustrates an exemplarymap 1600 of sub-pixels 1602 sampled during rasterization to generate apixel map. Arbitrarily, the map on the right 1600 _(O) may be used forodd pixels, while the map on the left 1600 _(E) may be used for evenpixels. When a shape or feature of a pattern to be written is rendered,its X & Y locations are placed “over” the map to determine whichsubsamples to set to one (“turn on”). As previously described, for someembodiments, the sampled sub-pixel data may be easily converted to graylevel using so-called “tally logic”, essentially counting all of thesubsamples which are set to one. Details of such logic are described indetail in the previously referenced U.S. Pat. No. 5,533,170.

Conversion of sampled sub-pixels into grayscale values is illustrated byFIG. 17A, which shows an exemplary shape 1711 _(A) that intersects fourpixels 1710. Starting from the upper left pixel 1710 and workingclockwise, the resultant grayscale values (doses) for these four pixelsare 11, 9, 10, and 13 (assuming minimum and maximum grayscale values of0 and 16, respectively). It should also be noted that more preciseinformation may be discovered by examining the sub-pixel data. Forexample, it may be discovered that in the upper left and upper rightcorners of the shape 1711 _(A), there is at least 1/16 of each pixel1710 that has no dose. FIG. 17B illustrates another shape 1711 _(A) thatoverlaps nine pixels. In this case, the center pixel is completelycovered (i.e., all black) and will, therefore have a maximum grayscalevalue of 16.

FIGS. 18A and 18B illustrate examples of lower right convex and concavecorner detection overlays 1800 _(A) and 1800 _(B), respectively. Asillustrated, the convex corner detection overlay 1800 _(A) has threeregions: a region 1810 in which all the sub-pixels must be black (orset), a region 1820 in which at least some of the sub-pixels must bewhite (in other words, they can't all be black), and a region 1830 inwhich all the sub-pixels must be white. If some portion of an array ofpixels satisfies these conditions, a corner is detected where indicated.

For example, for the lower right convex corner detection overlay 1800_(A), the identified corner lies in a pixel containing the lower rightboundary point between the some-white region 1820 and the white region1830. Requiring the some-white region 1820 to be some mix of black andwhite, or at least not allowing it to be all black may prevent multiplecorners from being detected (e.g., the requirements of the overlay mightotherwise be satisfied and indicate adjacent pixels are corners).Illustratively, the area occupied by the black region 1810 andsome-white region 1820 of the convex corner detection overlay 1800 _(A)measures 1-¼ pixels high and 1-¼ pixels wide. As illustrated in FIG.18B, the concave corner detection overlay 1800 _(B) is identical to theconvex corner detection overlay 1800 _(A), with the exception that theblack region 1810 and the white region 1830 are interchanged and thesome-white region 1820 is replaced by a some-black region 1840.

Applying Corner Detection Overlays

FIGS. 19A-19D illustrate the application of convex corner detectionoverlays 1800 _(A) to a 3×3 array 1900 of pixels 1910 to detect cornersof a shape 1911 lying therein (e.g., as in step 1508 of FIG. 15). Asillustrated, pixels 1910 of the array 1900 are labeled from 0 to 9beginning from the top left. In general, the corner detection overlays1800 are “slid” around in the array (e.g., in ¼-pixel steps in the X andY directions) until the sub-pixel conditions defining the overlay aresatisfied. As will be described in greater detail below, in somehardware implementations, the overlay is not actually slid around, butrather logic provided therein simultaneously detects all corners in the3×3 array.

FIG. 19A shows the “position” of an overlay 1800 _(A-UL) within thearray 1900 to detect an upper left convex corner of the shape 1911 inpixel 0. As illustrated, all sub-pixels within the black region 1810 ofthe overlay are completely covered by the shape 1911 and are black,while the sub-pixels within the white region 1830 are completely outsidethe shape 1911 and are white. Finally, some of the sub-pixels within thesome-white region 1820 are covered by the shape 1911, while some arenot, resulting in a mix of black and white sub-pixels. Thus, all of theconditions imposed by the overlay are satisfied, indicating an upperleft convex corner is located in pixel 0. It should be noted, however,that moving the overlay just slightly down or right (e.g., ¼ pixel ineither direction), would cause the some-white region to contain allblack sub-pixels and, hence, a corner would not be detected, althoughthe corner indicator would still be located in pixel 0.

In a similar manner, convex corner templates 1800 _(A-UR), 1800 _(A-LR),and 1800 _(A-LL), may be applied to detect the remaining convex cornersof the shape 1911 in pixels 2, 8, and 6, respectively, as illustrated inFIGS. 19B-D. While the shape 1911 does not have concave corners, itshould be readily apparent that the concave corner templates 1800 _(B)may be applied to arrays of pixels in a similar manner to detect concavecorners lying therein.

While there are two “strict” regions 1810 and 1820 of the overlays 1800in which all the sub-pixels contained therein must be either all blackor all white, respectively, pixels contained in the some-white region1820 may either be all white or some white and some black. Because ofthis ambiguity in region 1830, it is possible that more than one pixelmay be detected as having, in effect, the same corner, such as when ashape aligns perfectly on a pixel border.

This situation is illustrated in FIG. 20A, which shows a shape 2011 thatlies in pixels 1, 2, 4, and 5 of an array 2000. As illustrated, a convexcorner of the shape 2011 lies on a border between pixels 3 and 4. Inthis case, the overlay will find that both pixels 3 and 4 have convexcorners. For example, with the overlay 1800 _(A-LL) in the positionshown in FIG. 20B, pixel 4 will be identified as containing the corner.Shifting the overlay to the left a ¼ pixel, to the position shown inFIG. 20C, on the other hand, pixel 3 will be identified as containingthe corner. As previously described, it may be undesirable to detectcorners in adjacent pixels, due to the possibility of corner correctionsforming an unwanted bridge or gap in the pattern being written.

Such adjacent corners may be resolved by performing some type ofpost-detection corner processing. One simple example of such processingwould be to pick, as the corner pixel, the outermost pixel for convexcorners or innermost pixel for concave corners. Applying this approachin the example illustrated in FIGS. 20B and 20C, pixel 3 is theouter-most (most “left”) with respect to other pixel (pixel 4)identified as containing the lower left convex corner, so pixel 3 wouldbe chosen as having the corner.

Corner Tags

In addition to merely detecting a corner within a pixel, it may also bedesirable to determine a precise position within the pixel that thecorner lies. Such a precise position may be determined by examining thesampled sub-pixels to determine exactly which are covered by the shapecontaining the corner and may allow for more precise dosage control whencorrecting a detected corner (e.g., different corrective doses may beused depending on where in a pixel the corner is located). For someembodiments, a pixel may be divided into regions and an N-bit number,referred to herein as a corner tag, may be generated to identify theregion in which a detected corner pixel lies.

For example, a pixel map 2100 _(A) shown in FIG. 21A may be divided into16 regions 2102 _(A), illustratively labeled 0-F (using hexadecimalnotation). Accordingly, a 4-bit corner tag may be used to identify oneof the 16 regions 2102 _(A) containing the corner. FIG. 21A alsoillustrates use of the pixel map 2100 _(A) in conjunction with theconvex corner detection overlay 1800 _(A-UL) to detect an upper-leftconvex corner in a pixel 2110 and a corner tag indicating the cornerlies within a region ‘B’ of the pixel 2110. As will be described ingreater detail below, corner tags may be used to retrieve a set ofcorner correction registers containing correction factors that maydiffer depending on the corresponding region. In other words, for eachdifferent type of detectable corner, a 4-bit corner tag may be used toretrieve one of 16 different sets of correction factors, allowingprecise control of radiation dose at a detected corner.

While 16 regions may provide precise corner position information, forsome applications, less precision may be required. Therefore, asillustrated in FIG. 21B, a pixel map 2100 _(B) may be divided into 4regions 2102 _(B), illustratively labeled 0-3. Accordingly, a 2-bitcorner tag may be used to identify one of the 4 regions 2102 _(B) andretrieve a corresponding set of corner correction registers. Asillustrated in FIG. 21B, the pixel map 2100 _(B) may be used inconjunction with the convex corner detection overlay 1800A-UL to detectan upper-left convex corner in a pixel 2110 and a corner tag indicatingthe corner lies within a region ‘3’ of the pixel 2110. One skilled inthe art will recognize that the number of regions, as well as the numberof correction registers used for any given application may be chosenbased on a number of considerations, such as the needs of the particularapplication, available system resources, cost, and the like.

As previously described, corner tags may be used to retrieve a set ofcorrection registers containing correction factors specific to anidentified region within a pixel that contains a detected corner. Forsome embodiments, the correction registers may include independentlyadjustable 16-bit correction factors for use in adjusting the radiateddose (grayscale values) of the detected corner pixel, as well as anumber of surrounding pixels. As illustrated in FIG. 22, a differentgroup of correction registers 2210 may be provided for each differenttype of detectable corner. Each group may include a different set ofcorrection registers for each region identifiable by a corner tag. Forexample, assuming a 2-bit corner tag, each group may include 4 sets ofcorrection registers 2210 ₀₋₃.

Illustratively, each set of correction registers may include onecorrection register containing a correction factor for adjusting thegrayscale value of a detected corner pixel. Additionally, each set mayinclude three correction registers containing correction factors foradjusting the grayscale values of surrounding pixels, in order topropagate increased dose outwardly (for convex corners) or remove doseinwardly (for concave corners). In effect, the corner correctionregisters work to weight the correction based on the corner type and taggenerated. For some embodiments, up to four pixels may be modified: theprimary pixel, where the corner was located, a neighboring pixel cornerat a 45° angle from the corner, a pixel to the left (or right, based onthe corner found) and a pixel above (or below). Depending on the cornertype and corner tag, as few as one pixel may be modified (e.g., by thecorresponding correction registers to zero).

Because there are 8 possible corner types and (for this example) 4registers for each corner tag, 128 16-bit registers are required tocover all corrections if there are 4 identifiable corner positionswithin a pixel (e.g., 2-bit corner tags are used) or 512 16-bitregisters if there are 16 identifiable corner positions (e.g., a 4-bitcorner tag is used). This programmability allows users to project cornercorrection doses with a high degree of accuracy and also allows theprojected dose to take on arbitrary shapes, such as a triangle.

The use of these correction registers is illustrated in FIG. 23 whichshows a pixel map 2300 for a rendered shape 2311 having an upper-leftconvex corner detected in region ‘0’ of a middle pixel. The exampleillustrated in FIG. 23 assumes a 2-bit corner tag is used. Using thecorner tag ‘0’, a set of correction registers 2210 ₀ for an upper-leftconvex corner may be retrieved. The correction factor contained in oneregister (illustratively Register 3) may be used to adjust the grayscalevalue of the corner pixel, while the correction factors contained in theother registers (illustratively Registers 0-2) may be used to adjust thegrayscale values of “corrected” surrounding pixels 2310 _(C). For someembodiments, to adjust the grayscale values of the identified pixels,the four correction registers may be logically OR'd with existingsub-pixel data (prior to generating grayscale values therefrom).Alternatively, grayscale values may be modified directly based on thecorrection registers.

Exemplary Hardware for Area-Based Corner Correction

FIG. 24 illustrates an exemplary hardware implementation 2400 that maybe used to perform the area-based corner correction, based on sampledsub-pixel data. As with the previously described approaches, arasterizer 2404 may receive a data file 2402 representing a pattern tobe written and sample a number of sub-pixel locations covered by thepattern. Rather than simply generate and output a pixel map of grayscalevalues (e.g., 5-bit values generated by tallying the number of sampledsub-pixels that are set), the rasterizer 2404 may output the actual(e.g., 16-bit) sub-pixel data to allow for area-based corner correction.As illustrated, this sub-pixel data may be stored in a frame buffer 2406where it may be accessed by a corner detection and correction unit 2410.

As illustrated, the corner detection and correction unit 2410 mayinclude a corner detection unit 2418 that receives sub-pixel data fromthe frame buffer 2406. As illustrated, for some embodiments, the cornerdetection unit may receive sub-pixel data for a “frame” of pixels (e.g.,16 pixels) and simultaneously apply corner detection overlays to arraysof pixels therein to detect corner pixels, as previously described.Because, for some embodiments, the detection regions of the overlays maybe 1-¼ pixels high and wide (e.g., white plus some-white regions ofconvex corner overlays), it may be necessary to include border pixelsaround a frame to allow for corners that at an edge or would be off a“visible” frame. The corner detection unit 2418 may also generate cornertags identifying positions within detected corner pixels that containthe corners.

The corner data (e.g., identified corners, corner types, and cornertags) may be forwarded to a corner correction unit 2420 configured toperform corner correction. FIG. 25 illustrates exemplary operations 2500that may be performed by the corner correction unit 2420. At step 2502,the corner correction unit 2420 receives the corner data. At step 2504,a loop of operations (2506-2512) to be performed to correct eachidentified corner is entered.

At steps 2506 and 2508, the corner type and corner tag identifying theposition of a corner within a selected corner, respectively, areobtained. At step 2510, correction values (e.g., stored in cornercorrection registers 2210) are retrieved for the corner type and cornertag combination. At step 2512, the grayscale values of the identifiedcorner pixel and neighboring pixels are adjusted using the retrievedcorrection values. As previously described, for some embodiments,grayscale values may be adjusted by logical OR'ing the correction valueswith the sub-pixel information which will lead to corrected grayscalevalues, for example, during a grayscale conversion process (e.g.,tallying set sub-pixel bits). Once corrections have been made for eachidentified corner, the pattern is written using the modified pixel map(with the adjusted grayscale values), at step 2514.

Efficient Hierarchical Hardware Implementation

Components of the corner correction and detection unit 2410 may beimplemented using any combination of suitable hardware components, suchas FPGAs and custom ASICs. Due to the potentially large amount ofsub-pixel data that may be processed using the area-based approach,however, the number of gates required in such hardware components mayapproach component limitations. Therefore, for some embodiments, it maybe desirable to perform some type of optimization in an effort tominimize the number of gates required to implement the corner correctionfunctionality.

FPGA technology commonly consists of primitive elements that have fourinputs and one output. By taking advantage of this basic building block,one embodiment of an efficient area-based corner detection algorithm maybe implemented in an FPGA using a hierarchical approach using differentlayers of logic to generate different levels of data objects based onsub-pixel data. Such an implementation is shown in the corner detectionunit 2410 of FIG. 26, in which a first logical layer 2620 (e.g., using4-input/1-output primitives) is utilized to combine sets of 4 sub-pixelsto generate “Quad” outputs. A second logical layer 2622 is utilized tocombine sets of 4 Quads to generate “Blocks,” which may be combined byyet a third logical layer 2624 to generate corner signals. Theprimitives used in the logical layers may be configured to implementcombinatorial logic equations, in an effort to apply the previouslydescribed corner detection overlays, in parallel, to a plurality ofpixels in a sub-sample pixel array 2602 while minimizing overall gatecount.

FIG. 27 illustrates exemplary odd and even sub-pixel maps 2600 _(O) and2600 _(E), respectively, for adjacent pixels that may be used togenerate a set of quads Q0-Q7. The logic layer 2620 used to generate thequads, in effect, generates an output signal as a function of foursub-pixels inputs. The quads are collectively used to indicate the areaof a pixel, or set of pixels, covered by a corner, therefore, thecorresponding logic layer is typically not a direct summing of setsub-pixels. Rather, each quad represents 4/16 of a pixel and is dividedinto four portions (labeled as P1-P4). If there is portion of a quadthat does not contain a subsample (such as portion P3 of quad Q0), it iseffectively not considered in the corresponding equation. On the otherhand, if a portion of the quad has two subsamples (such as portion P1 ofquad Q0), then the two subsamples are OR'd together. Thus, the logiclayer 2620 may implement the following equations for quads Q0-Q3:

Q 0=(s 0|s 1)&s 2&s 3

Q 1=s 4&(s 5|s 6)&s 7

Q2=s 8&s 9&s 10&s 11, and

Q3=s12&s13&s14&s15

where the | and & symbols represent logical OR and logical ANDfunctions, respectively, and the sampled sub-pixels s0-s15 are from theodd pixel map 2700 _(A). Similar equations may be implemented togenerate quads Q4-Q7 using sampled sup-pixels from the even pixel map2700 _(E).

As illustrated in FIG. 26, the second logical layer 2622 includes a setof primitive elements that each combines 4 quads to generate a block.Thus, as each quad represents 4/16 the area of a pixel, a block has thesame dimensions as a pixel. As previously described, corner detectionoverlays may be, in effect, slid in ¼ pixel increments within a pixelarray. Therefore, it may be desirable to generate quads that overlayadjacent pixels. For example, referring again to FIG. 27, a quad labeledas Q3.25 may be generated from subsamples in 3 portions (P2-P4)contained in an odd pixel and 1 portion (P1) contained in an adjacenteven pixel, a quad labeled Q3.5 may be generated from subsamples in 2portions (P3-P4) contained in the odd pixel and 2 portions (P1-P2)contained in the adjacent even pixel, and a quad labeled Q3.75 may begenerated from subsamples in 1 portion (P4) contained in the odd pixeland 3 portions (P1-P3) contained in the adjacent even pixel. These“overlapping” quads may be combined to generate blocks that are notaligned on pixel borders.

FIG. 28 contains exemplary diagrams that illustrate how blocks 2802 maybe combined to detect a lower right convex corner by ensuring a set ofpixels satisfies the requirements of the detection overlay 1800 _(A)shown in FIG. 18A. In effect, various blocks 2802 are generated for anarray of sub-pixel data having the same dimensions as the cornerdetection overlay 1800 _(A), and the third logical layer 2624 implementslogic to ensure the requirements of the detection overlay are satisfied.

For example, a first block, labeled B0 and shown in the upper-leftdiagram, may be assembled from 4 quads contained in the upper leftcorner of the array, which corresponds to the “must be black” region1810 of the overlay 1800 _(A). Accordingly, a functional unit in thelogical layer 2624 used to generate a lower left convex corner signalmust ensure each of the sampled sub-pixels contained in the quads usedto generate block B0 are all ones. Similarly, blocks B1_, B2_, and B3_may be assembled from various quads in an effort to cover the whiteregion 1830. The underscore indicates that these blocks should begenerated from quads with all zero subsamples. As these three blocks donot entirely cover the white region 1830, additional blocks B5_ and B6_(shown in the upper-right diagram) may be constructed to cover theremaining portions. Blocks B4, B7, and B8 (shown in the upper-right,lower-left, and lower-right diagrams, may be generated to cover thesome-white region 1820.

Using the blocks described above, the third logical layer 2624 maydetect lower-right convex corners using the following equation:

C_(CVX-LR)=B0&B1_&B2_&B3_&(!B4|!B7|!B8)&B5_&B6 _(—)

where the symbol ! indicates a logical NOT function. Thus, this equationmay be interpreted as follows: block BO must have all ones, blocks B1_,B2_B3_, B5 and B6 must be all zeroes, while at least one sub-pixel inblocks B4, B7, or B8 must be a one. Similar block-based equations may bedevised to implement the corner detection overlays for the other cornertypes. Further, one skilled in the art will recognize that severalcombinations of blocks may be used to detect any particular corner typeand the exact combination of blocks used may be selected arbitrarily. Inany case, implementing the hierarchical scheme described herein mayallow for efficient hardware utilization and reduce overall gate count.The use of quads, blocks, and corner detection separated in this manneralso allows efficient pipelining of the operations (with multipleoperations performed each clock cycle), allowing overall detection andcorrection operations to be done at a maximum clock rate and reducingoverall pattern writing time.

CONCLUSION

By manipulating the grayscale values of pixels (post-rasterization), theamount of radiation dose at or near pixel corners may be increased ordecreased to compensate for boundary effects. As a result, the actualcorners of a pattern being written may more closely resemble the idealcorners of the pattern without increasing the size of the data filerepresenting the pattern or data transfer times.

While the foregoing is directed to embodiments of the present invention,other and further embodiments of the invention may be devised withoutdeparting from the basic scope thereof, and the scope thereof isdetermined by the claims that follow.

1. A method for adjusting corners of a pattern to be written into asensitive recording surface, comprising: generating sub-pixel data foruse in creating grayscale values for pixels by sampling sub-pixellocations of pixels that are covered by the pattern; detecting cornerpixels in the array, in which corners of the pattern lie, by examiningthe sub-pixel data; and adjusting grayscale values of at least one of:one or more detected corner pixels and one or more pixels neighboringone or more detected corner pixels.
 2. The method of claim 1, whereindetecting corner pixels comprises examining the sub-pixel data to detectconvex and concave corners of differing orientations.
 3. The method ofclaim 2, wherein examining the sub-pixel data to detect convex andconcave corners of differing orientations comprises: constructing anarray of pixels and corresponding sub-pixel data; and comparing a set ofcorner detection overlays to the sub-pixel data of the array.
 4. Themethod of claim 3, wherein: each corner detection overlay is smaller inat least one dimension than the array of pixels; and comparing the setof corner detection overlays to the sub-pixel data of the arraycomprises comparing the set of corner detection overlays to sub-arraysof sub-pixel data to detect corners at different pixel locations withinthe array.
 5. The method of claim 4, wherein at least two of thesub-arrays are offset from each other in at least one direction by lessthan one pixel.
 6. The method of claim 5, wherein at least two of thesub-arrays are offset from each other in at least one direction by aquarter pixel.
 7. The method of claim 1, wherein: detecting cornerpixels in the array, in which corners of the pattern lie, by examiningthe sub-pixel data comprises detecting the same corner in adjacentpixels; and selecting only one of the adjacent pixels as a corner pixel.8. The method of claim 7, wherein selecting only one of the adjacentpixels as a corner pixel comprises: selecting an inner-most adjacentpixel if the detected corner pixels are concave corner pixels; andselecting an outer-most adjacent pixel if the detected corner pixels areconvex corner pixels.
 9. The method of claim 1, further comprising:identifying a position within a detected corner pixel in which a cornerlies; and wherein adjusting the grayscale values comprises adjusting atleast one grayscale value based on a corner correction factor retrieved,at least in part, using the identified position.
 10. The method of claim8, wherein the corner correction factor is retrieved, at least in part,using a type and orientation of the detected corner.
 11. The method ofclaim 1, wherein adjusting the grayscale values comprises: increasinggrayscale values of at least one of a convex corner pixel containing aconvex corner and one or more pixels neighboring the convex cornerpixel; and decreasing grayscale values of at least one of a concavecorner pixel containing a concave corner and one or more pixelsneighboring the concave corner pixel.
 12. A method for adjusting cornersof a pattern to be written into a sensitive recording surface,comprising: generating sub-pixel data by sampling sub-pixel locations ofpixels that are covered by the pattern; constructing an array of thepixels with corresponding sub-pixel data; detecting corner pixels in thearray by comparing a set of sub-pixel data in the array with one or morecorner detection overlays; and adjusting grayscale values of at leastone of: one or more detected corner pixels and one or more pixelsneighboring one or more detected corner pixels.
 13. The method of claim12, wherein each corner detection overlay defines a first region inwhich all sub-pixel data must be of a first value, a second region inwhich all sub-pixel data must be of a second value, and a third regionin which at least some of the sub-pixel data must not be of the secondvalue
 14. The method of claim 13, wherein the one or more cornerdetection overlays comprise one or more convex corner detection overlaysdefining the first region in which all sub-pixel data must be a one andthe second region in which all sub-pixel data must be a zero.
 15. Themethod of claim 13, wherein the one or more corner detection overlayscomprise one or more concave corner detection overlays defining thefirst region in which all sub-pixel data must be a zero and the secondregion in which all sub-pixel data must be a zero.
 16. The method ofclaim 13, wherein: the first and third regions of each corner detectionoverlay are adjacent; and the combined length of the first and thirdregions is greater than or equal to a length of one and one quarterpixel.
 17. The method of claim 12, wherein: constructing the array ofthe pixels with corresponding sub-pixel data comprises constructing anarray of pixels greater in dimension than the corner detection overlays;and comparing a set of sub-pixel data in the array with one or morecorner detection overlays comprises comparing multiple sets of sub-pixeldata with the one or more corner detection overlays in parallel.
 18. Themethod of claim 12, further comprising, for each detected corner pixel,identifying a position within the detected corner pixel containing acorresponding corner.
 19. The method of claim 18, wherein adjustinggrayscale values of at least one of: one or more detected corner pixelsand one or more pixels neighboring the corner pixels comprises:retrieving one or more correction factors based on an identifiedposition within a detected corner pixel containing a correspondingcorner; and adjusting one or more grayscale values based on theretrieved correction factors.
 20. The method of claim 19, whereinretrieving one or more correction factors based on an identifiedposition within a detected corner pixel containing a correspondingcorner comprises retrieving the one or more correction factors based onthe identified position and a corner type associated with the detectedcorner pixel.
 21. The method of claim 20, wherein the one or morecorrection factors comprise: a first correction factor for use inadjusting the grayscale value of the detected corner pixel; and at leasta second correction factor for use in adjusting the grayscale values ofone or more pixels neighboring the detected corner pixel
 22. The methodof claim 18, wherein identifying a position within the detected cornerpixel comprises generating an N-bit corner tag, wherein N is an integer.23. The method of claim 22, wherein N=4.
 24. A system for writing apattern in a resistive surface, comprising: a rasterizer for generatingsub-pixel data by sampling sub-pixel locations of pixels that arecovered by the pattern; a corner detection unit for detecting cornerpixels in an array of pixels by examining sub-pixel data correspondingto the pixels in the array; and a corner correction unit for adjustinggrayscale values of at least one of: one or more detected corner pixelsand one or more pixels neighboring the corner pixels.
 25. The system ofclaim 24, wherein the corner detection unit is configured to generatecorner tags identifying positions within corner pixels that containcorners.
 26. The system of claim 25, wherein the corner correction unitis configured to adjust grayscale values of at least one of: a detectedcorner pixel and one or more pixels neighboring the detected cornerpixel using one or more correction factors retrieved based on acorresponding corner tag.
 27. The system of claim 26, wherein the one ormore correction factors are retrieved based on the corresponding cornertag and a corner type associated with the detected corner pixel.
 28. Thesystem of claim 26, wherein the one or more correction factors areretrieved based on the corresponding corner tag, the corner typeassociated with the detected corner pixel, and an orientation of thecorner contained in the detected corner pixel.
 29. The system of claim26, wherein the one or more correction factors comprise at least a firstcorrection factor for use in adjusting the grayscale value of thedetected corner pixel and at least a second correction factor for use inadjusting the grayscale value of one or more pixels neighboring thedetected corner pixel.
 30. The system of claim 29, wherein the first andsecond correction factors are independently adjustable by a user.